// 全局变量
let currentTab = 'capture';
let allPrompts = [];
let allTags = new Set();
let apiSettings = null;

// 初始化
document.addEventListener('DOMContentLoaded', () => {
  // 加载API设置
  loadApiSettings().then(() => {
    // 更新API状态指示器
    updateApiIndicator();
    
    // 检查是否需要重新计算向量
    checkAndRecalculateVectors();
  });
  
  // 加载保存的提示词
  loadPrompts();
  
  // 设置标签切换
  setupTabs();
  
  // 设置按钮点击事件
  setupButtonHandlers();
  
  // 初始化显示界面
  updateUI();
});

// 加载API设置
async function loadApiSettings() {
  return new Promise((resolve) => {
    chrome.storage.local.get('apiSettings', (result) => {
      apiSettings = result.apiSettings || {
        apiPlatform: null,
        baseUrl: null,
        apiKey: null,
        chatModel: null,
        embeddingModel: null
      };
      resolve();
    });
  });
}

// 更新API状态指示器
function updateApiIndicator() {
  const indicator = document.getElementById('api-platform-indicator');
  
  // 检查API是否已配置
  if (!apiSettings || !apiSettings.apiPlatform || !apiSettings.apiKey) {
    indicator.textContent = '未配置API';
    indicator.className = 'not-configured';
  } else {
    let platformName = '';
    switch(apiSettings.apiPlatform) {
      case 'aliyun': platformName = '阿里云'; break;
      case 'guiji': platformName = '硅基流'; break;
      case 'openai': platformName = 'OpenAI'; break;
      default: platformName = apiSettings.apiPlatform;
    }
    
    indicator.textContent = `${platformName}: ${apiSettings.chatModel}`;
    indicator.className = apiSettings.apiPlatform;
  }
}

// 设置标签切换
function setupTabs() {
  const tabs = document.querySelectorAll('.tab');
  tabs.forEach(tab => {
    tab.addEventListener('click', () => {
      tabs.forEach(t => t.classList.remove('active'));
      tab.classList.add('active');
      
      const tabId = tab.dataset.tab;
      currentTab = tabId;
      
      const tabContents = document.querySelectorAll('.tab-content');
      tabContents.forEach(content => content.classList.remove('active'));
      document.getElementById(tabId).classList.add('active');
      
      updateUI();
    });
  });
}

// 设置按钮点击事件
function setupButtonHandlers() {
  // 捕获选中文本按钮
  document.getElementById('capture-selected').addEventListener('click', captureSelectedText);
  
  // 保存提示词按钮
  document.getElementById('save-prompt').addEventListener('click', saveCurrentPrompt);
  
  // 搜索按钮
  document.getElementById('search-btn').addEventListener('click', searchPrompts);
  
  // 导出按钮
  document.getElementById('export-all').addEventListener('click', exportAllPrompts);
  
  // 导入按钮
  document.getElementById('import-data').addEventListener('click', importData);
  
  // 设置按钮
  document.getElementById('open-settings').addEventListener('click', openSettings);
  
  // 标题栏设置图标
  document.getElementById('open-settings-icon').addEventListener('click', openSettings);
}

// 打开设置页面
function openSettings() {
  chrome.runtime.openOptionsPage();
}

// 从Chrome存储加载提示词
function loadPrompts() {
  chrome.storage.local.get('prompts', (result) => {
    if (result.prompts) {
      allPrompts = result.prompts;
      
      // 提取所有标签
      allTags = new Set();
      allPrompts.forEach(prompt => {
        if (prompt.tags) {
          prompt.tags.forEach(tag => allTags.add(tag));
        }
      });
      
      updateUI();
    }
  });
}

// 捕获当前选中的文本
function captureSelectedText() {
  chrome.tabs.query({active: true, currentWindow: true}, (tabs) => {
    chrome.scripting.executeScript({
      target: {tabId: tabs[0].id},
      function: () => {
        return window.getSelection().toString();
      }
    }, (result) => {
      if (result && result[0] && result[0].result) {
        document.getElementById('prompt-text').value = result[0].result;
        showStatus('已捕获选中文本');
      } else {
        showStatus('未找到选中文本');
      }
    });
  });
}

// 保存当前提示词
async function saveCurrentPrompt() {
  const promptText = document.getElementById('prompt-text').value.trim();
  
  if (!promptText) {
    showStatus('提示词不能为空');
    return;
  }
  
  if (!apiSettings || !apiSettings.apiPlatform || !apiSettings.apiKey) {
    showStatus('请先配置API设置');
    return;
  }
  
  showStatus('正在处理提示词...');
  
  try {
    // 调用 LLM API 进行处理
    const promptData = await processWithLLM(promptText);
    
    // 检查是否有相似的提示词
    if (allPrompts.length > 0) {
      // 为向量对象添加文本属性，以便在向量不可用时使用文本相似度
      const vectorWithText = promptData.vector ? 
        { ...promptData.vector, text: promptText } : 
        { text: promptText };
      
      // 计算与现有提示词的相似度
      const similarPrompts = findSimilarPrompts(vectorWithText, 0.7, 5);
      
      // 如果有相似提示词，显示提醒对话框
      if (similarPrompts.length > 0) {
        showSimilarPromptDialog(promptData, similarPrompts);
        return;
      }
    }
    
    // 没有相似提示词或相似度低于阈值，直接保存
    savePromptToStorage(promptData);
    
  } catch (error) {
    showStatus('保存失败: ' + error.message);
  }
}

// 将提示词保存到存储中
function savePromptToStorage(promptData) {
  // 添加到存储
  allPrompts.push(promptData);
  
  // 更新标签集合
  if (promptData.tags) {
    promptData.tags.forEach(tag => allTags.add(tag));
  }
  
  // 保存到 Chrome 存储
  chrome.storage.local.set({prompts: allPrompts}, () => {
    document.getElementById('prompt-text').value = '';
    showStatus('提示词已保存');
    updateUI();
  });
}

// 查找相似提示词
function findSimilarPrompts(vector, threshold = 0.85, limit = 5) {
  // 两种方式查找相似提示词：
  // 1. 基于向量余弦相似度（如果向量可用）
  // 2. 直接基于文本内容匹配（向量不可用时的备选方案）
  
  const similarities = allPrompts.map(prompt => {
    let similarity = 0;
    
    // 方法1：使用向量相似度
    if (vector && Array.isArray(vector) && vector.length > 0 && 
        prompt.vector && Array.isArray(prompt.vector) && prompt.vector.length > 0) {
      // 计算向量相似度
      similarity = cosineSimilarity(vector, prompt.vector);
    } 
    // 方法2：简单文本匹配（备选方案）
    else if (vector.text && prompt.text) {
      // 如果向量不可用，则使用文本直接比较（仅用于测试，实际使用应移除此部分）
      const text1 = vector.text.toLowerCase();
      const text2 = prompt.text.toLowerCase();
      
      // 计算编辑距离相似度
      if (text1 === text2) {
        similarity = 1.0; // 完全匹配
      } else if (text1.includes(text2) || text2.includes(text1)) {
        similarity = 0.9; // 一个是另一个的子串
      } else {
        // 计算两文本共有词的比例
        const words1 = new Set(text1.split(/\s+/));
        const words2 = new Set(text2.split(/\s+/));
        
        // 计算共有词数
        let commonWords = 0;
        words1.forEach(word => {
          if (words2.has(word)) commonWords++;
        });
        
        // 计算Jaccard相似度
        similarity = commonWords / (words1.size + words2.size - commonWords);
      }
    }
    
    return { prompt, similarity };
  });
  
  // 按相似度从高到低排序，并过滤低于阈值的
  return similarities
    .filter(item => item.similarity >= threshold)
    .sort((a, b) => b.similarity - a.similarity)
    .slice(0, limit);
}

// 计算余弦相似度
function cosineSimilarity(vecA, vecB) {
  // 如果向量长度不一致，进行处理
  const minLength = Math.min(vecA.length, vecB.length);
  let dotProduct = 0;
  let normA = 0;
  let normB = 0;
  
  for (let i = 0; i < minLength; i++) {
    dotProduct += vecA[i] * vecB[i];
    normA += vecA[i] * vecA[i];
    normB += vecB[i] * vecB[i];
  }
  
  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
}

// 显示相似提示词对话框
function showSimilarPromptDialog(newPrompt, similarPrompts) {
  // 创建对话框元素
  const dialog = document.createElement('div');
  dialog.className = 'similar-prompts-dialog';
  
  // 创建标题
  const title = document.createElement('h3');
  title.textContent = '发现相似提示词';
  dialog.appendChild(title);
  
  // 创建提示文本
  const promptText = document.createElement('p');
  promptText.textContent = '以下提示词与您要保存的内容相似度较高，是否继续保存？';
  dialog.appendChild(promptText);
  
  // 创建相似提示词列表
  const list = document.createElement('div');
  list.className = 'similar-prompts-list';
  
  similarPrompts.forEach(({ prompt, similarity }) => {
    const item = document.createElement('div');
    item.className = 'similar-prompt-item';
    
    const titleElement = document.createElement('div');
    titleElement.className = 'similar-prompt-title';
    titleElement.textContent = prompt.title || '未命名提示词';
    
    const similarityElement = document.createElement('div');
    similarityElement.className = 'similar-prompt-similarity';
    similarityElement.textContent = `相似度: ${(similarity * 100).toFixed(1)}%`;
    
    item.appendChild(titleElement);
    item.appendChild(similarityElement);
    
    // 点击标题查看完整提示词内容
    item.addEventListener('click', () => {
      showPromptDetailDialog(prompt);
    });
    
    list.appendChild(item);
  });
  
  dialog.appendChild(list);
  
  // 按钮容器
  const buttonContainer = document.createElement('div');
  buttonContainer.className = 'dialog-buttons';
  
  // 取消按钮
  const cancelBtn = document.createElement('button');
  cancelBtn.className = 'btn secondary';
  cancelBtn.textContent = '取消保存';
  cancelBtn.onclick = () => {
    document.body.removeChild(dialog);
    showStatus('已取消保存');
  };
  
  // 继续保存按钮
  const saveBtn = document.createElement('button');
  saveBtn.className = 'btn success';
  saveBtn.textContent = '继续保存';
  saveBtn.onclick = () => {
    document.body.removeChild(dialog);
    savePromptToStorage(newPrompt);
  };
  
  buttonContainer.appendChild(cancelBtn);
  buttonContainer.appendChild(saveBtn);
  dialog.appendChild(buttonContainer);
  
  // 添加到文档
  document.body.appendChild(dialog);
}

// 显示提示词详情对话框
function showPromptDetailDialog(prompt) {
  const detailElement = document.createElement('div');
  detailElement.className = 'prompt-detail';
  
  // 添加标题
  const titleElement = document.createElement('h3');
  titleElement.textContent = prompt.title || '未命名提示词';
  detailElement.appendChild(titleElement);
  
  // 添加内容
  const contentElement = document.createElement('div');
  contentElement.className = 'prompt-full-content';
  contentElement.textContent = prompt.text;
  detailElement.appendChild(contentElement);
  
  // 添加标签
  if (prompt.tags && prompt.tags.length > 0) {
    const tagsElement = document.createElement('div');
    tagsElement.className = 'prompt-tags dialog-tags';
    
    prompt.tags.forEach(tag => {
      const tagSpan = document.createElement('span');
      tagSpan.className = 'tag';
      tagSpan.textContent = tag;
      tagsElement.appendChild(tagSpan);
    });
    
    detailElement.appendChild(tagsElement);
  }
  
  // 创建模态框
  const modal = document.createElement('div');
  modal.className = 'modal';
  modal.appendChild(detailElement);
  
  // 添加复制按钮
  const copyBtn = document.createElement('button');
  copyBtn.className = 'btn secondary';
  copyBtn.textContent = '复制提示词';
  copyBtn.style.position = 'absolute';
  copyBtn.style.bottom = '16px';
  copyBtn.style.left = '16px';
  copyBtn.onclick = () => {
    navigator.clipboard.writeText(prompt.text)
      .then(() => showStatus('已复制到剪贴板'))
      .catch(() => showStatus('复制失败'));
  };
  detailElement.appendChild(copyBtn);
  
  // 添加关闭按钮
  const closeBtn = document.createElement('button');
  closeBtn.className = 'modal-close';
  closeBtn.textContent = '×';
  closeBtn.onclick = () => document.body.removeChild(modal);
  
  modal.appendChild(closeBtn);
  document.body.appendChild(modal);
}

// 检查并重新计算向量
async function checkAndRecalculateVectors() {
  chrome.storage.local.get(['needRecalculateVectors', 'prompts'], async (result) => {
    if (result.needRecalculateVectors && result.prompts && result.prompts.length > 0) {
      // 显示重新计算进度对话框
      showRecalculatingDialog(result.prompts.length);
      
      // 逐一重新计算向量
      const updatedPrompts = [];
      let processedCount = 0;
      
      for (const prompt of result.prompts) {
        try {
          // 获取新的向量
          const vector = await getTextEmbedding(prompt.text);
          
          // 更新提示词向量
          updatedPrompts.push({
            ...prompt,
            vector: vector
          });
          
          // 更新进度
          processedCount++;
          updateRecalculatingProgress(processedCount, result.prompts.length);
        } catch (error) {
          console.error('向量重新计算失败:', error);
          // 如果失败，保留原向量
          updatedPrompts.push(prompt);
          processedCount++;
          updateRecalculatingProgress(processedCount, result.prompts.length);
        }
      }
      
      // 保存更新后的提示词
      chrome.storage.local.set({
        prompts: updatedPrompts,
        needRecalculateVectors: false
      }, () => {
        // 关闭进度对话框
        hideRecalculatingDialog();
        showStatus('向量重新计算完成');
        
        // 更新全局变量
        allPrompts = updatedPrompts;
        updateUI();
      });
    }
  });
}

// 显示重新计算进度对话框
function showRecalculatingDialog(totalCount) {
  const dialog = document.createElement('div');
  dialog.id = 'recalculating-dialog';
  dialog.className = 'recalculating-dialog';
  
  const title = document.createElement('h3');
  title.textContent = '正在重新计算向量';
  dialog.appendChild(title);
  
  const progressText = document.createElement('div');
  progressText.id = 'recalculating-progress-text';
  progressText.textContent = `0 / ${totalCount}`;
  dialog.appendChild(progressText);
  
  const progressBar = document.createElement('div');
  progressBar.className = 'progress-bar-container';
  
  const progressFill = document.createElement('div');
  progressFill.id = 'recalculating-progress-fill';
  progressFill.className = 'progress-bar-fill';
  progressFill.style.width = '0%';
  
  progressBar.appendChild(progressFill);
  dialog.appendChild(progressBar);
  
  document.body.appendChild(dialog);
}

// 更新重新计算进度
function updateRecalculatingProgress(current, total) {
  const progressText = document.getElementById('recalculating-progress-text');
  const progressFill = document.getElementById('recalculating-progress-fill');
  
  if (progressText && progressFill) {
    const percentage = Math.round((current / total) * 100);
    progressText.textContent = `${current} / ${total}`;
    progressFill.style.width = `${percentage}%`;
  }
}

// 隐藏重新计算进度对话框
function hideRecalculatingDialog() {
  const dialog = document.getElementById('recalculating-dialog');
  if (dialog) {
    document.body.removeChild(dialog);
  }
}

// 获取文本嵌入向量
async function getTextEmbedding(text) {
  if (!apiSettings || !apiSettings.apiPlatform || !apiSettings.apiKey) {
    // 如果API未配置，返回一致性向量
    return generateConsistentVector(text);
  }
  
  try {
    const response = await fetch(`${apiSettings.baseUrl}/embeddings`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiSettings.apiKey}`
      },
      body: JSON.stringify({
        model: apiSettings.embeddingModel,
        input: text,
        encoding_format: 'float'
      })
    });
    
    if (!response.ok) {
      throw new Error(`嵌入请求失败: ${response.status}`);
    }
    
    const data = await response.json();
    
    // 根据不同平台处理返回数据
    if (apiSettings.apiPlatform === 'openai' || apiSettings.apiPlatform === 'aliyun') {
      // OpenAI和阿里云兼容模式格式
      return data.data[0].embedding;
    } else if (apiSettings.apiPlatform === 'guiji') {
      // 硅基流格式
      return data.data[0].embedding;
    } else {
      // 其他平台，尝试从常见路径获取
      return data.embedding || data.data[0].embedding || data.data.embedding;
    }
  } catch (error) {
    console.error('获取嵌入向量失败:', error);
    // 如果API调用失败，返回一致性向量
    return generateConsistentVector(text);
  }
}

// 使用 LLM 处理提示词
async function processWithLLM(text) {
  // 实际API调用
  try {
    // 检查文本是否为空或无意义
    if (!text || text.trim() === '') {
      return {
        text: text,
        title: '未命名提示词',
        tags: ['未知'],
        vector: generateConsistentVector(text || ''),
        createdAt: new Date().toISOString(),
        platform: apiSettings.apiPlatform,
        model: apiSettings.chatModel
      };
    }
    
    // 1. 获取文本嵌入向量
    const vector = await getTextEmbedding(text);
    
    // 2. 然后使用LLM获取分类标签和标题
    const tagsResponse = await fetch(`${apiSettings.baseUrl}/chat/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiSettings.apiKey}`
      },
      body: JSON.stringify({
        model: apiSettings.chatModel,
        messages: [
          {
            role: "system",
            content: "你是一个提示词分类专家。你的任务是为提示词添加合适的标签和一个简短的标题。标题应该概括提示词的作用，不超过20个字。请返回2-5个标签，格式为JSON数组。如果提示词内容为空或无意义，返回['未知']作为标签。返回格式应为: {\"tags\": [\"标签1\", \"标签2\"], \"title\": \"简短标题\"}"
          },
          {
            role: "user",
            content: text
          }
        ],
        stream: apiSettings.apiPlatform === 'aliyun' && apiSettings.chatModel.startsWith('qwq') ? true : false,
        response_format: { type: "json_object" }
      })
    });
    
    if (!tagsResponse.ok) {
      throw new Error(`标签请求失败: ${tagsResponse.status}`);
    }
    
    // 处理流式响应（阿里云QWQ模型）
    if (apiSettings.apiPlatform === 'aliyun' && apiSettings.chatModel.startsWith('qwq')) {
      const reader = tagsResponse.body.getReader();
      let tagsContent = '';
      
      while (true) {
        const {done, value} = await reader.read();
        if (done) break;
        
        const chunk = new TextDecoder().decode(value);
        const lines = chunk.split('\n').filter(line => line.trim() !== '');
        
        for (const line of lines) {
          if (line.startsWith('data:')) {
            const jsonStr = line.slice(5).trim();
            if (jsonStr === '[DONE]') continue;
            
            try {
              const data = JSON.parse(jsonStr);
              if (data.choices && data.choices[0].delta) {
                if (data.choices[0].delta.content) {
                  tagsContent += data.choices[0].delta.content;
                }
                // 阿里云QWQ模型特有的思考过程内容
                if (data.choices[0].delta.reasoning_content) {
                  console.log('思考过程:', data.choices[0].delta.reasoning_content);
                }
              }
            } catch (e) {
              console.error('解析JSON失败:', e);
            }
          }
        }
      }
      
      // 解析生成的标签和标题
      try {
        const responseObj = JSON.parse(tagsContent);
        return {
          text: text,
          title: responseObj.title || generateDefaultTitle(text),
          tags: responseObj.tags || [],
          vector: vector,
          createdAt: new Date().toISOString(),
          platform: apiSettings.apiPlatform,
          model: apiSettings.chatModel
        };
      } catch (e) {
        console.error('解析返回数据失败:', e);
        return {
          text: text,
          title: generateDefaultTitle(text),
          tags: ['未知'],
          vector: vector,
          createdAt: new Date().toISOString(),
          platform: apiSettings.apiPlatform,
          model: apiSettings.chatModel
        };
      }
    } else {
      // 处理普通响应
      try {
        const tagsData = await tagsResponse.json();
        const responseObj = JSON.parse(tagsData.choices[0].message.content);
        
        return {
          text: text,
          title: responseObj.title || generateDefaultTitle(text),
          tags: responseObj.tags || [],
          vector: vector,
          createdAt: new Date().toISOString(),
          platform: apiSettings.apiPlatform,
          model: apiSettings.chatModel
        };
      } catch (e) {
        console.error('解析返回数据失败:', e);
        return {
          text: text,
          title: generateDefaultTitle(text),
          tags: ['未知'],
          vector: vector,
          createdAt: new Date().toISOString(),
          platform: apiSettings.apiPlatform,
          model: apiSettings.chatModel
        };
      }
    }
  } catch (error) {
    console.error('API调用失败:', error);
    
    // 生成默认响应
    const vector = await getTextEmbedding(text);
    return {
      text: text,
      title: generateDefaultTitle(text),
      tags: ['未知'],
      vector: vector,
      createdAt: new Date().toISOString(),
      platform: apiSettings.apiPlatform,
      model: apiSettings.chatModel
    };
  }
}

// 生成一致的向量 - 基于文本的哈希算法
function generateConsistentVector(text) {
  // 使用简单的哈希函数为文本生成数值
  function simpleHash(str) {
    let hash = 0;
    if (str.length === 0) return hash;
    
    for (let i = 0; i < str.length; i++) {
      const char = str.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // 转换为32位整数
    }
    return hash;
  }
  
  // 生成32维向量，每一维都是基于原文本的某种变形的哈希值
  const vector = new Array(32);
  for (let i = 0; i < 32; i++) {
    // 为每个维度添加不同的"盐"来创建变化
    const salted = text + i.toString();
    const hashValue = simpleHash(salted);
    
    // 将哈希值规范化到-1到1之间
    vector[i] = (hashValue % 1000) / 1000;
  }
  
  return vector;
}

// 生成默认标题
function generateDefaultTitle(text) {
  // 截取前20个字符作为标题，如果长度不足则全部使用
  const maxLength = 20;
  if (text.length <= maxLength) {
    return text;
  }
  
  // 尝试在合适的位置截断（如句号、逗号等）
  const breakChars = ['.', '。', '!', '！', '?', '？', ',', '，', ';', '；', '\n'];
  let cutPosition = -1;
  
  for (let i = 0; i < breakChars.length; i++) {
    const pos = text.indexOf(breakChars[i], 5); // 从第5个字符开始寻找断点
    if (pos > 0 && pos <= maxLength) {
      cutPosition = pos;
      break;
    }
  }
  
  if (cutPosition === -1) {
    // 如果没找到合适的断点，就直接截取前20个字符
    return text.substring(0, maxLength) + '...';
  } else {
    // 在断点处截断
    return text.substring(0, cutPosition + 1);
  }
}

// 搜索提示词
async function searchPrompts() {
  try {
    const searchQuery = document.getElementById('search-input')?.value.trim() || '';
    const resultsContainer = document.getElementById('search-results');
    
    if (!resultsContainer) {
      console.error('找不到搜索结果容器');
      return;
    }
    
    resultsContainer.innerHTML = '';
    
    if (!searchQuery && !document.querySelector('.tag.search-tag.active')) {
      showStatus('请输入搜索内容或选择标签');
      return;
    }
    
    let tagQueries = [];
    let textQuery = '';
    
    // 解析搜索查询
    if (searchQuery) {
      // 提取标签查询
      const tagMatches = searchQuery.match(/#(\S+)/g);
      if (tagMatches) {
        tagQueries = tagMatches.map(tag => tag.substring(1).toLowerCase());
        
        // 移除标签部分，留下纯文本查询
        let remainingQuery = searchQuery;
        tagMatches.forEach(tag => {
          remainingQuery = remainingQuery.replace(tag, '');
        });
        textQuery = remainingQuery.trim();
        
        // 高亮匹配的标签
        const tagElements = document.querySelectorAll('.tag.search-tag');
        
        tagElements.forEach(tag => {
          const tagText = tag.textContent.toLowerCase();
          if (tagQueries.includes(tagText)) {
            tag.classList.add('active');
          } else {
            tag.classList.remove('active');
          }
        });
      } else {
        // 纯文本搜索
        textQuery = searchQuery;
        
        // 清除所有标签高亮
        const tagElements = document.querySelectorAll('.tag.search-tag');
        tagElements.forEach(tag => {
          tag.classList.remove('active');
        });
      }
    }
    
    showStatus('正在搜索...');
    
    try {
      // 检查是否包含标签搜索
      if (tagQueries.length > 0) {
        // 执行多标签搜索
        let results = allPrompts.filter(prompt => {
          if (!prompt.tags) return false;
          
          // 对于每个要查询的标签，检查提示词是否包含该标签
          return tagQueries.every(tagQuery => 
            prompt.tags.some(tag => tag.toLowerCase() === tagQuery)
          );
        });
        
        // 如果还有文本查询，进一步过滤结果
        if (textQuery) {
          results = results.filter(prompt => 
            prompt.text.toLowerCase().includes(textQuery.toLowerCase())
          );
        }
        
        displaySearchResults(results);
        return;
      }
      
      // 纯文本向量搜索
      if (textQuery && apiSettings && apiSettings.apiPlatform && apiSettings.apiKey) {
        // 获取搜索查询的向量表示
        const searchVector = await getTextEmbedding(textQuery);
        
        // 计算所有提示词与搜索查询的相似度
        const results = allPrompts.map(prompt => {
          // 如果提示词有向量，使用余弦相似度
          let similarity = 0;
          if (prompt.vector && Array.isArray(prompt.vector) && prompt.vector.length > 0) {
            similarity = cosineSimilarity(searchVector, prompt.vector);
          } else {
            // 如果没有向量，使用文本相似度
            similarity = calculateTextSimilarity(textQuery, prompt.text);
          }
          
          return { prompt, similarity };
        });
        
        // 按相似度排序
        const sortedResults = results
          .sort((a, b) => b.similarity - a.similarity)
          .slice(0, 50); // 最多展示50条结果
        
        // 过滤出相似度足够高的结果
        const filteredResults = sortedResults.filter(item => item.similarity > 0.1);
        
        if (filteredResults.length === 0) {
          resultsContainer.innerHTML = '<div class="no-results">没有找到匹配的提示词</div>';
          showStatus('搜索完成，无结果');
          return;
        }
        
        // 显示结果
        filteredResults.forEach(({ prompt, similarity }) => {
          const promptElement = createPromptElement(prompt);
          
          // 在提示词元素上添加相似度信息
          const similarityElement = document.createElement('div');
          similarityElement.className = 'similarity-score';
          similarityElement.textContent = `相似度: ${(similarity * 100).toFixed(1)}%`;
          promptElement.appendChild(similarityElement);
          
          resultsContainer.appendChild(promptElement);
        });
        
        showStatus(`找到 ${filteredResults.length} 个结果`);
      } else {
        // 如果API未配置或者没有文本查询，回退到简单文本搜索
        const query = textQuery || searchQuery;
        const results = allPrompts.filter(prompt => 
          prompt.text.toLowerCase().includes(query.toLowerCase()) ||
          (prompt.tags && prompt.tags.some(tag => 
            tag.toLowerCase().includes(query.toLowerCase())
          ))
        );
        
        displaySearchResults(results);
      }
    } catch (error) {
      console.error('搜索失败:', error);
      showStatus('搜索失败');
      
      // 回退到简单文本搜索
      const query = textQuery || searchQuery;
      const results = allPrompts.filter(prompt => 
        prompt.text.toLowerCase().includes(query.toLowerCase()) ||
        (prompt.tags && prompt.tags.some(tag => 
          tag.toLowerCase().includes(query.toLowerCase())
        ))
      );
      
      displaySearchResults(results);
    }
  } catch (error) {
    console.error('搜索失败:', error);
    showStatus('搜索失败');
  }
}

// 显示搜索结果
function displaySearchResults(results) {
  const resultsContainer = document.getElementById('search-results');
  
  if (results.length === 0) {
    resultsContainer.innerHTML = '<div class="no-results">没有找到匹配的提示词</div>';
    showStatus('搜索完成，无结果');
    return;
  }
  
  // 限制结果数量
  const limitedResults = results.slice(0, 50);
  
  limitedResults.forEach(prompt => {
    resultsContainer.appendChild(createPromptElement(prompt));
  });
  
  showStatus(`找到 ${limitedResults.length} 个结果`);
}

// 计算文本相似度（无向量时的备选方案）
function calculateTextSimilarity(query, text) {
  // 转换为小写进行比较
  const queryLower = query.toLowerCase();
  const textLower = text.toLowerCase();
  
  // 完全匹配
  if (textLower === queryLower) {
    return 1.0;
  }
  
  // 包含关系
  if (textLower.includes(queryLower)) {
    return 0.8;
  }
  
  // 计算词汇重叠
  const queryWords = new Set(queryLower.split(/\s+/).filter(w => w.length > 1));
  const textWords = new Set(textLower.split(/\s+/).filter(w => w.length > 1));
  
  if (queryWords.size === 0 || textWords.size === 0) {
    return 0;
  }
  
  // 计算共有词数
  let commonWords = 0;
  queryWords.forEach(word => {
    if (textWords.has(word)) commonWords++;
  });
  
  // 计算Jaccard相似度
  const similarity = commonWords / (queryWords.size + textWords.size - commonWords);
  return similarity;
}

// 导出所有提示词
function exportAllPrompts() {
  if (allPrompts.length === 0) {
    showStatus('没有提示词可导出');
    return;
  }
  
  const dataStr = JSON.stringify(allPrompts, null, 2);
  const dataBlob = new Blob([dataStr], {type: 'application/json'});
  const url = URL.createObjectURL(dataBlob);
  
  const a = document.createElement('a');
  a.href = url;
  a.download = `prompts_export_${new Date().toISOString().slice(0,10)}.json`;
  a.click();
  
  URL.revokeObjectURL(url);
  showStatus('提示词已导出');
}

// 导入数据
function importData() {
  const input = document.createElement('input');
  input.type = 'file';
  input.accept = '.json';
  
  input.onchange = (e) => {
    const file = e.target.files[0];
    if (!file) return;
    
    const reader = new FileReader();
    reader.onload = (event) => {
      try {
        const importedData = JSON.parse(event.target.result);
        
        if (Array.isArray(importedData)) {
          // 合并导入的提示词
          allPrompts = [...allPrompts, ...importedData];
          
          // 更新标签集合
          allPrompts.forEach(prompt => {
            if (prompt.tags) {
              prompt.tags.forEach(tag => allTags.add(tag));
            }
          });
          
          // 保存到 Chrome 存储
          chrome.storage.local.set({prompts: allPrompts}, () => {
            showStatus(`已导入 ${importedData.length} 个提示词`);
            updateUI();
          });
        } else {
          showStatus('导入失败: 无效的数据格式');
        }
      } catch (error) {
        showStatus('导入失败: ' + error.message);
      }
    };
    
    reader.readAsText(file);
  };
  
  input.click();
}

// 更新UI
function updateUI() {
  try {
    // 更新标签显示
    renderTags();
    
    // 为所有标签添加点击事件
    document.querySelectorAll('.tag.search-tag').forEach(tag => {
      tag.addEventListener('click', function() {
        // 切换标签的活动状态
        this.classList.toggle('active');
        
        // 收集所有活动标签
        const activeTags = document.querySelectorAll('.tag.search-tag.active');
        const searchInput = document.getElementById('search-input');
        
        if (!searchInput) return; // 如果元素不存在，直接返回
        
        // 从搜索框中提取非标签文本
        let searchText = searchInput.value;
        const tagMatches = searchText.match(/#(\S+)/g) || [];
        
        // 移除所有旧标签
        tagMatches.forEach(tag => {
          searchText = searchText.replace(tag, '');
        });
        
        // 清理搜索文本
        searchText = searchText.trim();
        
        // 构建新的搜索词
        let newSearchText = searchText;
        
        // 添加活动标签到搜索框
        if (activeTags.length > 0) {
          const tagTexts = Array.from(activeTags).map(tag => `#${tag.textContent}`);
          if (searchText) {
            newSearchText = `${searchText} ${tagTexts.join(' ')}`;
          } else {
            newSearchText = tagTexts.join(' ');
          }
        }
        
        // 更新搜索框
        searchInput.value = newSearchText;
        
        // 执行搜索
        searchPrompts();
      });
    });
    
    // 添加搜索输入事件监听，处理标签变化
    const searchInput = document.getElementById('search-input');
    if (searchInput) {
      searchInput.addEventListener('input', function() {
        try {
          // 检查搜索框中的标签变化并更新UI
          const tagMatches = this.value.match(/#(\S+)/g) || [];
          const tagElements = document.querySelectorAll('.tag.search-tag');
          
          // 重置所有标签状态
          tagElements.forEach(tag => {
            tag.classList.remove('active');
          });
          
          // 激活匹配的标签
          if (tagMatches.length > 0) {
            tagElements.forEach(tag => {
              const tagText = tag.textContent.toLowerCase();
              if (tagMatches.some(t => t.substring(1).toLowerCase() === tagText)) {
                tag.classList.add('active');
              }
            });
          }
        } catch (error) {
          console.error('处理搜索输入失败:', error);
        }
      });
    }
  } catch (error) {
    console.error('更新UI失败:', error);
  }
  
  // 其他UI更新逻辑（根据当前选项卡）
  try {
    if (currentTab === 'search') {
      // 根据当前标签更新搜索结果
      searchPrompts();
    } else if (currentTab === 'manage') {
      // 更新提示词列表
      renderPromptsList();
    }
  } catch (error) {
    console.error('更新特定选项卡UI失败:', error);
  }
}

// 渲染标签显示
function renderTags() {
  try {
    // 更新标签筛选标题
    const filterTitle = document.querySelector('.filter-title');
    if (filterTitle) {
      // 清除原有内容
      filterTitle.innerHTML = '';
      
      // 添加标题文本
      const titleText = document.createElement('span');
      titleText.textContent = '标签筛选:';
      filterTitle.appendChild(titleText);
      
      // 添加切换按钮
      const toggleBtn = document.createElement('button');
      toggleBtn.className = 'toggle-tags-btn';
      toggleBtn.textContent = '隐藏标签';
      toggleBtn.onclick = toggleTagsContainer;
      filterTitle.appendChild(toggleBtn);
    }
    
    // 更新标签筛选
    const tagsFilter = document.getElementById('tags-filter');
    if (!tagsFilter) {
      console.error('找不到标签过滤器容器元素');
      return;
    }
    
    tagsFilter.innerHTML = '';
    
    // 过滤掉空标签
    const validTags = Array.from(allTags).filter(tag => tag && tag.trim() !== '');
    
    if (validTags.length > 0) {
      // 创建标签容器
      const tagsWrapper = document.createElement('div');
      tagsWrapper.className = 'tags-wrapper';
      
      // 只显示前10个标签（按字母顺序排序）
      validTags.sort().slice(0, 10).forEach(tag => {
        const tagSpan = document.createElement('span');
        tagSpan.className = 'tag search-tag';
        tagSpan.textContent = tag;
        tagsWrapper.appendChild(tagSpan);
      });
      
      // 添加到标签筛选区域
      tagsFilter.appendChild(tagsWrapper);
    } else {
      tagsFilter.innerHTML = '<div class="no-tags">无标签</div>';
    }
    
    // 恢复标签栏显示状态
    const filterContainer = document.querySelector('.filter-container');
    if (filterContainer) {
      const tagsVisible = localStorage.getItem('tagsVisible');
      if (tagsVisible === 'false') {
        filterContainer.classList.add('hidden');
        const toggleBtn = document.querySelector('.toggle-tags-btn');
        if (toggleBtn) toggleBtn.textContent = '显示标签';
      }
    }
  } catch (error) {
    console.error('渲染标签失败:', error);
  }
}

// 切换标签栏显示/隐藏
function toggleTagsContainer() {
  try {
    const filterContainer = document.querySelector('.filter-container');
    const toggleBtn = document.querySelector('.toggle-tags-btn');
    
    if (!filterContainer || !toggleBtn) return;
    
    const isHidden = filterContainer.classList.contains('hidden');
    
    if (isHidden) {
      // 显示标签栏
      filterContainer.classList.remove('hidden');
      toggleBtn.textContent = '隐藏标签';
      localStorage.setItem('tagsVisible', 'true');
    } else {
      // 隐藏标签栏
      filterContainer.classList.add('hidden');
      toggleBtn.textContent = '显示标签';
      localStorage.setItem('tagsVisible', 'false');
    }
  } catch (error) {
    console.error('切换标签栏显示失败:', error);
  }
}

// 通过标签筛选提示词
function filterPromptsByTags() {
  const activeTags = Array.from(document.querySelectorAll('.tag.active')).map(tag => tag.textContent);
  const resultsContainer = document.getElementById('search-results');
  resultsContainer.innerHTML = '';
  
  if (activeTags.length === 0) {
    return;
  }
  
  const results = allPrompts.filter(prompt => 
    prompt.tags && prompt.tags.some(tag => activeTags.includes(tag))
  );
  
  if (results.length === 0) {
    resultsContainer.innerHTML = '<div class="no-results">没有找到匹配的提示词</div>';
    return;
  }
  
  results.forEach(prompt => {
    resultsContainer.appendChild(createPromptElement(prompt));
  });
}

// 创建提示词元素
function createPromptElement(prompt, includeActions = false) {
  const promptElement = document.createElement('div');
  promptElement.className = 'prompt-item';
  promptElement.dataset.id = prompt.createdAt; // 使用创建时间作为唯一ID
  
  const titleElement = document.createElement('div');
  titleElement.className = 'prompt-title';
  titleElement.textContent = prompt.title || '未命名提示词';
  
  const contentElement = document.createElement('div');
  contentElement.className = 'prompt-content';
  // 只显示前40个字符
  contentElement.textContent = prompt.text.length > 40 
    ? prompt.text.substring(0, 40) + '...' 
    : prompt.text;
  
  const tagsElement = document.createElement('div');
  tagsElement.className = 'prompt-tags';
  
  if (prompt.tags && prompt.tags.length > 0) {
    prompt.tags.forEach(tag => {
      const tagSpan = document.createElement('span');
      // 确保tag不为空
      if (tag && tag.trim()) {
        tagSpan.className = 'tag';
        tagSpan.textContent = tag;
        
        // 为标签添加删除按钮（在管理页面）
        if (includeActions) {
          const deleteBtn = document.createElement('span');
          deleteBtn.className = 'tag-delete';
          deleteBtn.innerHTML = '&times;';
          deleteBtn.title = '删除标签';
          deleteBtn.onclick = (e) => {
            e.stopPropagation();
            deleteTag(prompt.createdAt, tag);
          };
          tagSpan.appendChild(deleteBtn);
        }
        
        tagsElement.appendChild(tagSpan);
      }
    });
  }
  
  // 添加模型信息
  if (prompt.platform && prompt.model) {
    const modelSpan = document.createElement('span');
    modelSpan.className = `tag ${prompt.platform}`;
    modelSpan.textContent = prompt.model;
    modelSpan.style.opacity = '0.7';
    tagsElement.appendChild(modelSpan);
  }
  
  // 添加标签编辑功能（在管理页面）
  if (includeActions) {
    const tagActions = document.createElement('div');
    tagActions.className = 'tag-actions';
    
    const addTagBtn = document.createElement('button');
    addTagBtn.className = 'btn mini';
    addTagBtn.textContent = '+ 标签';
    addTagBtn.onclick = (e) => {
      e.stopPropagation(); // 防止触发提示词点击事件
      showAddTagDialog(prompt.createdAt);
    };
    
    tagActions.appendChild(addTagBtn);
    tagsElement.appendChild(tagActions);
  }
  
  promptElement.appendChild(titleElement);
  promptElement.appendChild(contentElement);
  promptElement.appendChild(tagsElement);
  
  // 添加操作按钮(对所有提示词都有)
  const actionsElement = document.createElement('div');
  actionsElement.className = 'prompt-actions';
  
  // 复制按钮 - 对所有提示词都显示
  const copyBtn = document.createElement('button');
  copyBtn.className = 'btn mini';
  copyBtn.textContent = '复制';
  copyBtn.onclick = (e) => {
    e.stopPropagation();
    navigator.clipboard.writeText(prompt.text)
      .then(() => showStatus('已复制到剪贴板'))
      .catch(() => showStatus('复制失败'));
  };
  actionsElement.appendChild(copyBtn);
  
  // 编辑按钮 - 对所有提示词都显示
  const editBtn = document.createElement('button');
  editBtn.className = 'btn mini primary';
  editBtn.textContent = '编辑';
  editBtn.onclick = (e) => {
    e.stopPropagation();
    showEditPromptDialog(prompt.createdAt);
  };
  actionsElement.appendChild(editBtn);
  
  // 删除按钮 - 只在管理页面显示
  if (includeActions) {
    const deleteBtn = document.createElement('button');
    deleteBtn.className = 'btn mini danger';
    deleteBtn.textContent = '删除';
    deleteBtn.onclick = (e) => {
      e.stopPropagation();
      deletePrompt(prompt.createdAt);
    };
    actionsElement.appendChild(deleteBtn);
  }
  
  promptElement.appendChild(actionsElement);
  
  // 点击提示词显示详情
  promptElement.addEventListener('click', () => {
    showPromptDetailDialog(prompt);
  });
  
  return promptElement;
}

// 删除标签
function deleteTag(promptId, tagToDelete) {
  // 找到对应的提示词
  const promptIndex = allPrompts.findIndex(p => p.createdAt === promptId);
  if (promptIndex === -1) return;
  
  // 删除标签
  const prompt = allPrompts[promptIndex];
  prompt.tags = prompt.tags.filter(tag => tag !== tagToDelete);
  
  // 更新标签集合
  updateTagsCollection();
  
  // 保存到存储
  chrome.storage.local.set({prompts: allPrompts}, () => {
    showStatus('标签已删除');
    updateUI();
  });
}

// 显示添加标签对话框
function showAddTagDialog(promptId) {
  // 创建对话框元素
  const dialog = document.createElement('div');
  dialog.className = 'tag-dialog';
  
  const input = document.createElement('input');
  input.type = 'text';
  input.placeholder = '输入新标签...';
  
  const buttonContainer = document.createElement('div');
  buttonContainer.className = 'dialog-buttons';
  
  const cancelBtn = document.createElement('button');
  cancelBtn.className = 'btn mini';
  cancelBtn.textContent = '取消';
  cancelBtn.onclick = () => document.body.removeChild(dialog);
  
  const addBtn = document.createElement('button');
  addBtn.className = 'btn mini success';
  addBtn.textContent = '添加';
  addBtn.onclick = () => {
    const newTag = input.value.trim();
    if (newTag) {
      addTag(promptId, newTag);
      document.body.removeChild(dialog);
    }
  };
  
  buttonContainer.appendChild(cancelBtn);
  buttonContainer.appendChild(addBtn);
  
  dialog.appendChild(input);
  dialog.appendChild(buttonContainer);
  
  // 添加到文档
  document.body.appendChild(dialog);
  input.focus();
  
  // 回车键添加标签
  input.addEventListener('keypress', (e) => {
    if (e.key === 'Enter') {
      const newTag = input.value.trim();
      if (newTag) {
        addTag(promptId, newTag);
        document.body.removeChild(dialog);
      }
    }
  });
}

// 添加标签
function addTag(promptId, newTag) {
  // 找到对应的提示词
  const promptIndex = allPrompts.findIndex(p => p.createdAt === promptId);
  if (promptIndex === -1) return;
  
  // 添加标签
  const prompt = allPrompts[promptIndex];
  if (!prompt.tags) prompt.tags = [];
  
  // 检查标签是否已存在
  if (!prompt.tags.includes(newTag)) {
    prompt.tags.push(newTag);
    
    // 更新标签集合
    allTags.add(newTag);
    
    // 保存到存储
    chrome.storage.local.set({prompts: allPrompts}, () => {
      showStatus('标签已添加');
      updateUI();
    });
  } else {
    showStatus('标签已存在');
  }
}

// 删除提示词
function deletePrompt(promptId) {
  if (!confirm('确定要删除这个提示词吗？')) return;
  
  // 找到对应的提示词并删除
  allPrompts = allPrompts.filter(p => p.createdAt !== promptId);
  
  // 更新标签集合
  updateTagsCollection();
  
  // 保存到存储
  chrome.storage.local.set({prompts: allPrompts}, () => {
    showStatus('提示词已删除');
    updateUI();
  });
}

// 更新标签集合
function updateTagsCollection() {
  allTags = new Set();
  allPrompts.forEach(prompt => {
    if (prompt.tags) {
      prompt.tags.forEach(tag => allTags.add(tag));
    }
  });
}

// 显示状态消息
function showStatus(message) {
  try {
    const statusElement = document.getElementById('status-message');
    if (statusElement) {
      statusElement.textContent = message;
      
      // 3秒后清除状态消息
      setTimeout(() => {
        if (statusElement) {
          statusElement.textContent = '';
        }
      }, 3000);
    }
  } catch (error) {
    console.error('显示状态消息失败:', error);
  }
}

// 显示编辑提示词对话框
function showEditPromptDialog(promptId) {
  // 找到对应的提示词
  const promptIndex = allPrompts.findIndex(p => p.createdAt === promptId);
  if (promptIndex === -1) return;
  
  const prompt = allPrompts[promptIndex];
  
  // 创建对话框元素
  const dialog = document.createElement('div');
  dialog.className = 'edit-dialog';
  
  // 创建标题
  const dialogTitle = document.createElement('h3');
  dialogTitle.textContent = '编辑提示词';
  dialog.appendChild(dialogTitle);
  
  // 创建标题编辑区
  const titleLabel = document.createElement('label');
  titleLabel.textContent = '标题 (不超过20字)';
  dialog.appendChild(titleLabel);
  
  const titleInput = document.createElement('input');
  titleInput.type = 'text';
  titleInput.value = prompt.title || '';
  titleInput.maxLength = 20;
  dialog.appendChild(titleInput);
  
  // 创建内容标签
  const contentLabel = document.createElement('label');
  contentLabel.textContent = '提示词内容';
  dialog.appendChild(contentLabel);
  
  // It should be a label for the textarea
  contentLabel.setAttribute('for', 'edit-prompt-content');
  
  // 创建文本编辑区
  const textarea = document.createElement('textarea');
  textarea.id = 'edit-prompt-content';
  textarea.value = prompt.text;
  textarea.rows = 8;
  dialog.appendChild(textarea);
  
  // 按钮容器
  const buttonContainer = document.createElement('div');
  buttonContainer.className = 'dialog-buttons';
  
  // 取消按钮
  const cancelBtn = document.createElement('button');
  cancelBtn.className = 'btn secondary';
  cancelBtn.textContent = '取消';
  cancelBtn.onclick = () => document.body.removeChild(dialog);
  
  // 保存按钮
  const saveBtn = document.createElement('button');
  saveBtn.className = 'btn success';
  saveBtn.textContent = '保存';
  saveBtn.onclick = async () => {
    const newTitle = titleInput.value.trim();
    const newText = textarea.value.trim();
    
    if (newText) {
      await updatePromptText(promptId, newText, newTitle);
      document.body.removeChild(dialog);
    } else {
      showStatus('提示词内容不能为空');
    }
  };
  
  buttonContainer.appendChild(cancelBtn);
  buttonContainer.appendChild(saveBtn);
  dialog.appendChild(buttonContainer);
  
  // 添加到文档
  document.body.appendChild(dialog);
  textarea.focus();
}

// 更新提示词内容
async function updatePromptText(promptId, newText, newTitle) {
  // 找到对应的提示词
  const promptIndex = allPrompts.findIndex(p => p.createdAt === promptId);
  if (promptIndex === -1) return;
  
  const prompt = allPrompts[promptIndex];
  
  // 检查内容是否有变化
  if (prompt.text === newText && prompt.title === newTitle) {
    showStatus('提示词内容未更改');
    return;
  }
  
  // 更新提示词内容和标题
  const contentChanged = prompt.text !== newText;
  prompt.text = newText;
  
  // 更新标题（如果为空，生成默认标题）
  prompt.title = newTitle || generateDefaultTitle(newText);
  
  // 如果内容有变化且API已配置，尝试更新标签
  if (contentChanged && apiSettings && apiSettings.apiPlatform && apiSettings.apiKey) {
    showStatus('正在更新标签...');
    try {
      // 调用 LLM API 获取新标签
      const promptData = await processWithLLM(newText);
      
      // 更新标签
      prompt.tags = promptData.tags;
      prompt.vector = promptData.vector;
      
      // 如果用户没有自定义标题，则使用AI生成的标题
      if (!newTitle) {
        prompt.title = promptData.title;
      }
      
      // 更新全局标签集合
      updateTagsCollection();
    } catch (error) {
      console.error('更新标签失败:', error);
      showStatus('标签更新失败，仅保存文本更改');
    }
  }
  
  // 保存到存储
  chrome.storage.local.set({prompts: allPrompts}, () => {
    showStatus('提示词已更新');
    updateUI();
  });
} 